home *** CD-ROM | disk | FTP | other *** search
/ Netware Super Library / Netware Super Library.iso / pgm_tool / lu62 / dallocat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-03  |  9.2 KB  |  343 lines
  1. /*
  2.  *                        DEALLOCATE
  3.  *
  4.  * Function: has deal with DEALLOCATE verb. If the defined resource
  5.  *           exist and the conversation has appropriate state,
  6.  *           PS calls an appopriate subroutine for proceeding the processing
  7.  *           of the DEALLOCATE verb.
  8.  *
  9.  * Input: Pointer to "deallocate" structure.
  10.  *
  11.  * CopyRight 1995. Nicholas Poljakov all rights reserved.
  12.  */
  13. #include <stdio.h>
  14. #include <sendat.h>
  15. #include <state1.h>
  16. #include <rcb.h>
  17. #include <tcb.h>
  18. #include <drcb.h>
  19. #include <dall.h>
  20. #include <cma.h>
  21. #include <partner.h>
  22. #include <string.h>
  23. int sk_r_wt(void *);
  24. int SendBlock(void *, void *);
  25. int setrc(void *, void *);
  26. int sendhsf(void *);
  27. int sendhs(void *);
  28. int sendbm(void *, void *);
  29. int sendat(void *);
  30. int rtsend(void *);
  31. unsigned long rmfmh5(void *, void *);
  32. int recwait(void *);
  33. int rcvru(void *, void *);
  34. int rcvhs(void *, void *, void *, void *);
  35. int ralloc(void *, void *);
  36. int psrm(int, void *, void *);
  37. int ps_conv(int, void *);
  38. int proterr(void *, unsigned long);
  39. int preptrcv(void *, void *);
  40. int post_rcb(void *);
  41. struct repass *postopen(void *);
  42. int phsrec(void *);
  43. int pfmh5(void *);
  44. int opndst(void *);
  45. int obtsess(void *, unsigned char);
  46. int Lrf_handler(void *);
  47. int get_sess(void *, void *);
  48. int get_attr(void *);
  49. int fsm_error(unsigned char, void *);
  50. int fsm_conv(unsigned char, unsigned char, void *);
  51. int flush (void *);
  52. int dcp(void *);
  53. int crtp(void *);
  54. int conv(void *);
  55. int chkparm(void *, void *);
  56. int check_end(unsigned int, void *);
  57. struct rqb *call_appl(void *);
  58. int buffmng(unsigned char, void *, void *, void *, unsigned, unsigned char, unsigned);
  59. unsigned long attltck(void *);
  60. unsigned long attacheck(void *);
  61. char *cgetmem(int, int);
  62. int sendhsf(void *);
  63. int opndst(void *);
  64. int alloc_rcb(void *, void *);
  65. int allocate(void *);
  66. int clsdst(void *);
  67. int bldfmh7(struct rcb *, unsigned long);
  68.  
  69. dealloc(pptr)
  70. struct deallocate *pptr;
  71. {
  72. extern struct psp psp_ini;
  73. struct rcb *ptr_rcb;
  74. struct tcb *ptr_tcb;
  75. struct drcb d_rcb;
  76. struct cma ar;
  77. struct pnlu *p_partner;
  78.  
  79. int  fsm_conv();
  80. int  fsm_error();
  81. char s;
  82. char r;
  83. int code;
  84.  
  85. #if OS_TYPE == 1
  86. /*********  Trace facility **********/
  87. unsigned int rtype;   /* type of record */
  88. unsigned int pnum;    /* point number */
  89. char pname[8];        /* name of module */
  90. char *drec;       /* record for dump */
  91. int  lenr;            /* record length */
  92.  
  93. rtype = INPROC;
  94. strcpy(pname, "dalloc");
  95. pnum = 1;
  96. drec = pptr;
  97. lenr = sizeof(struct deallocate);
  98. gtf(rtype, pname, pnum, drec, lenr);
  99. /***********************************/
  100. #endif
  101.  
  102.      s = 'S';
  103.      r = 'R';
  104.  
  105.      if (chkparm(pptr, &ar) == -1) {
  106.         return(0);
  107.      }
  108.      ptr_rcb = ar.p_rcb;
  109.      ptr_tcb = ar.p_tcb;
  110.  
  111.      /* Check if it RCB is in wait qeue */
  112.      if (sk_r_wt(ptr_rcb) == 0) {
  113.         pptr -> prim_rc = INCOMPLETE;
  114.         return (0);
  115.      }
  116.  
  117.      d_rcb.p_rcb = ptr_rcb;
  118.      d_rcb.p_tcb = ptr_tcb;
  119.  
  120.      p_partner = ptr_rcb -> p_partner;
  121.      if (p_partner -> lu_type == 0) {   /* for lu_type == 0 */
  122.         code = RM_DEACTIVATE_SESSION;   /* make clsdst */
  123.         psrm(code, ptr_rcb, 0);
  124.         return (0);                     /* and return */
  125.      }
  126.      code = DEALLOCATE_RCB;
  127.  
  128.     /*   ó  RCB  ºá¡«ß¿¼ ¬«ñ »α¿¼¿Γ¿óá  */
  129.        ptr_rcb ->verb_code = Deallocate;
  130.  
  131.      switch (pptr -> type)
  132.              {
  133.             case Flush: {
  134.                            dflush(pptr, ptr_tcb, ptr_rcb);
  135.                            psrm(code, &d_rcb, 0);
  136.                            break;
  137.                         }
  138.             case Confirm:
  139.                         {
  140.                            dconfirm(pptr, ptr_tcb, ptr_rcb);
  141.                            break;
  142.                         }
  143.             case Local:
  144.                         {
  145.                            psrm(code, &d_rcb, 0);
  146.                            break;
  147.                         }
  148.             case abend_prog:
  149.             case abend_svc:
  150.             case abend_timer:
  151.                         {
  152.                            dabend(pptr, ptr_tcb, ptr_rcb);
  153.                            psrm(code, &d_rcb, 0);
  154.                            break;
  155.                         }
  156.             default:
  157.                         {
  158.                            pptr -> prim_rc = INCOMPLETE;
  159.                return 0;
  160.                         }
  161.              }
  162. }
  163. dflush(pptr, p_tcb, p_rcb)
  164. struct deallocate *pptr;
  165. struct tcb *p_tcb;
  166. struct rcb *p_rcb;
  167. {
  168.     int type;
  169.     int state;
  170.     char *p;
  171.  
  172. #if OS_TYPE == 1
  173. /*********  Trace facility **********/
  174. unsigned int rtype;   /* type of record */
  175. unsigned int pnum;    /* point number */
  176. char pname[8];        /* name of module */
  177. char *drec;       /* record for dump */
  178. int  lenr;            /* record length */
  179.  
  180. rtype = INPROC;
  181. strcpy(pname, "dflush");
  182. pnum = 1;
  183. drec = pptr;
  184. lenr = sizeof(struct deallocate);
  185. gtf(rtype, pname, pnum, drec, lenr);
  186. /***********************************/
  187. #endif
  188.  
  189.  
  190.     if ((state = fsm_conv('S',Deallocate_flush,p_rcb)) == -1) {
  191.              pptr -> prim_rc = PORT_ABENDED;
  192.              return;
  193.     }
  194.     if (state == 1) {
  195.              pptr -> prim_rc = STATE_CHECK;
  196.              pptr -> sec_rc = DEALLOC_FLUSH_BAD_STATE;
  197.          return 0;
  198.     }
  199.  
  200.     if (p_rcb -> send_ll_remainder != 0) {
  201.         dcp(p_tcb);
  202.     }
  203.     switch (p_rcb -> error_state) {
  204.         case NO_RQS      :
  205.         case RCVD_ERROR  :
  206.                            {
  207.                              p = &((*p_rcb).first_out);
  208.                              type = Deallocate_flush;
  209.                              buffmng('A', NULL, p, p_rcb, 0, 0, type);
  210.                              sendhsf(p_rcb);
  211.                            }
  212.      }
  213.      pptr -> prim_rc = OK;
  214. }
  215.  
  216. dconfirm(pptr, p_tcb, p_rcb)
  217. struct deallocate *pptr;
  218. struct tcb *p_tcb;
  219. struct rcb *p_rcb;
  220. {
  221.     int type;
  222.     int state;
  223.     char s;
  224.     char *p;
  225.  
  226. #if OS_TYPE == 1
  227. /*********  Trace facility **********/
  228. unsigned int rtype;   /* type of record */
  229. unsigned int pnum;    /* point number */
  230. char pname[8];        /* name of module */
  231. char *drec;       /* record for dump */
  232. int  lenr;            /* record length */
  233.  
  234. rtype = INPROC;
  235. strcpy(pname, "dconf");
  236. pnum = 1;
  237. drec = pptr;
  238. lenr = sizeof(struct deallocate);
  239. gtf(rtype, pname, pnum, drec, lenr);
  240. /***********************************/
  241. #endif
  242.  
  243.     if (p_rcb -> send_ll_remainder != 0) {
  244.         dcp(p_tcb);
  245.     }
  246.     s = 'S';
  247.     if ((state = fsm_conv(s,Deallocate_confirm,p_rcb)) == -1) {
  248.              pptr -> prim_rc = PORT_ABENDED;
  249.          return 0;
  250.     }
  251.     if (state == 1) {
  252.              pptr -> prim_rc = STATE_CHECK;
  253.              pptr -> sec_rc = DEALLOC_FLUSH_BAD_STATE;
  254.          return 0;
  255.     }
  256.     switch (p_rcb -> error_state) {
  257.         case CONV_FAILURE_PROTOCOL_ERROR :
  258.                {
  259.                  pptr -> prim_rc = CONV_FAILURE_NO_RETRY;
  260.                  s = 'R';
  261.                  fsm_conv(s, RESOURCE_FAILURE_RC, p_rcb);
  262.                  break;
  263.                }
  264.         case CONV_FAILURE_SON:
  265.                {
  266.                  pptr -> prim_rc = CONV_FAILURE_RETRY;
  267.                  s = 'R';
  268.                  fsm_conv(s, RESOURCE_FAILURE_RC, p_rcb);
  269.                  break;
  270.                }
  271.         case ALLOCATE_FAILURE_RETRY :
  272.         case ALLOCATE_FAILURE_NO_RETRY :
  273.         case SYNC_LEVEL_NOT_SUPPORTED_BY_LU :
  274.                {
  275.                  pptr -> prim_rc = ALLOCATION_ERROR;
  276.                  pptr -> sec_rc = DEALLOC_CONFIRM_BAD_STATE;
  277.                  s = 'R';
  278.                  fsm_conv(s, RESOURCE_FAILURE_RC, p_rcb);
  279.                  break;
  280.                }
  281.         case RCVD_ERROR:
  282.                {
  283.                  pptr -> prim_rc = CONV_FAILURE_RETRY;
  284.                  s = 'R';
  285.                  fsm_conv(s, RESOURCE_FAILURE_RC, p_rcb);
  286.                  break;
  287.                }
  288.         case NO_RQS:
  289.                {
  290.                  p = &((*p_rcb).first_out);
  291.                  type = Deallocate_confirm;
  292.                  buffmng('A', NULL, p, p_rcb, 0, 0, type);
  293.                  /* No flush
  294.                  sendhs(p_rcb);
  295.                   */
  296.                  break;
  297.                }
  298.      }
  299. }
  300. dabend(pptr, p_tcb, p_rcb)
  301. struct deallocate *pptr;
  302. struct tcb *p_tcb;
  303. struct rcb *p_rcb;
  304. {
  305.     unsigned long sense;
  306.  
  307. #if OS_TYPE == 1
  308. /*********  Trace facility **********/
  309. unsigned int rtype;   /* type of record */
  310. unsigned int pnum;    /* point number */
  311. char pname[8];        /* name of module */
  312. char *drec;       /* record for dump */
  313. int  lenr;            /* record length */
  314.  
  315. rtype = INPROC;
  316. strcpy(pname, "dabend");
  317. pnum = 1;
  318. drec = pptr;
  319. lenr = sizeof(struct deallocate);
  320. gtf(rtype, pname, pnum, drec, lenr);
  321. /***********************************/
  322. #endif
  323.  
  324.     pptr -> prim_rc = OK;
  325.     if ((p_rcb -> error_state == NO_RQS)||
  326.    (p_rcb -> error_state == RCVD_ERROR))  {
  327.        if (pptr -> type == 2) { /* ABEND_PROG */
  328.             sense = 0x08640000;
  329.        }
  330.        if (pptr -> type == 3) { /* ABEND_SVC */
  331.             sense = 0x08640001;
  332.        }
  333.        if (pptr -> type == 4) { /* ABEND_TIMER */
  334.             sense = 0x08640002;
  335.        }
  336.        else
  337.             {
  338.                 sense = 0x08640000;
  339.             }
  340.        bldfmh7(p_rcb, sense); /* Build and send the FMH-7 */
  341.     }
  342. }
  343.